package cn.zld.sh.sh.util;

import android.content.Context;
import android.os.Environment;
import android.os.StatFs;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SDCardUtils {
	/**
	 * 遍历某个文件加下的内容
	 * 
	 * @param file
	 *            :文件名
	 * @param data
	 *            :数据的集合
	 * @return 如何文件不为空返回true，为空返回false
	 */
	public static boolean listDirectory(File file,
			List<Map<String, String>> data) {
		if (isMounted()) {
			// 遍历文件加下的内容
			File[] files = file.listFiles();
			if (files == null) {// 文件为空
				return false;
			}
			/**
			 * 处理文件不为空， 先清除之前的数据
			 */
			data.clear();
			/**
			 * 遍历文件夹
			 */
			for (File f : files) {
				Map<String, String> map = new HashMap<String, String>();
				/**
				 * 获得文件名
				 */
				String fileName = f.getName();
				/* 表示文件或文件夹 */
				String type = "";
				if (f.isDirectory()) {// 文件夹
					type = "dir";
				} else if (f.isFile()) {// 文件
					type = "file";
				}
				map.put("name", fileName);
				map.put("type", type);
				data.add(map);
			}
			return true;
		}
		return false;
	}

	/**
	 * 判断sdcard是否挂载
	 * 
	 * @return 如果挂载返回true，如果没有挂载返回false
	 */
	public static boolean isMounted() {
		if (Environment.MEDIA_MOUNTED.equals(Environment
				.getExternalStorageState())) {
			return true;
		}
		return false;
	}

	/**
	 * 获得sdcard的路劲
	 * 
	 * @return:如果有返回，没有则返回null
	 */
	public static String getSDCardPath() {
		if (isMounted()) {
			return Environment.getExternalStorageDirectory().getAbsolutePath();
		}
		return null;
	}

	/**
	 * 获得sdcard的总容量
	 * 
	 * @return:返回sdcard的总大小，没有返回0，单位为Mib
	 */
public static long getSize() {
		/**
		 * 先判断sdcard是否挂载
		 */
		if (isMounted()) {
			/**
			 * StatFs,用来计算文件系统存储空间大小的工具类
			 */
			StatFs sFs = new StatFs(getSDCardPath());
			/**
			 * 获得块的数量
			 * 已过时的方法 int count = sFs.getBlockCount();
			 */
			long count = sFs.getBlockCount();
			/**
			 * 获得每一块的大小
			 * 已过时的方法 int size = sFs.getBlockSize();
			 */
			long size = sFs.getBlockSize();
			return count * size / 1024 / 1024;
		}
		return 0;
	}

	/**
	 * 获得sdcard的可用空间
	 * 
	 * @return:返回sdcard的可用空间，没有返回0，单位为Mib
	 */
	 public static long getAvailableSize() {
		if (isMounted()) {
			/**
			 * StatFs,用来计算文件系统存储空间大小的工具类
			 */
			StatFs stat = new StatFs(getSDCardPath());
			/**
			 * 获得可用块的数量
			 */
			long availCount = stat.getAvailableBlocks();
			/**
			 * 获得获得每一块的大小
			 */
			long size = stat.getBlockSize();
			return availCount * size / 1024 / 1024;
		}
		return 0;
	}

	/**
	 * 将数据保存到sdcard
	 * 
	 * @param data
	 *            :保存的数据
	 * @param dir
	 *            :保存的路劲
	 * @param fileName
	 *            :文件名
	 * @return 保存成功返回true，失败返回false
	 */
	public static boolean saveDataIntoSDCard(byte[] data, String dir,
			String fileName) {
		if (isMounted()) {
			String path = getSDCardPath() + File.separator + dir;
			File file = new File(path);
			/**
			 * 先判断存储路径dir是否存在，如果不存在创建
			 */
			if (!file.exists()) {
				file.mkdirs();
			}
			/**
			 * 如果存在进行读写操作
			 */
			file = new File(path + File.separator + fileName);
			BufferedOutputStream bos = null;
			try {
				// 创建一个输出流
				bos = new BufferedOutputStream(new FileOutputStream(file));
				bos.write(data);
				bos.flush();
				return true;
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				try {
					if (bos != null) {
						// 如果流不为空，关闭
						bos.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return false;
	}

	/**
	 * 读取sdcard上的数据
	 * 
	 * @param dir
	 *            : 文件的路劲
	 * @param fileName
	 *            : 文件名
	 * @return 如果读取成功返回byte数组，否则返回null
	 */
	public static int getDataFromSDCard(String dir, String fileName) {
		if (isMounted()) {
			/**
			 * 获取文件所在的路径
			 */
			String path =dir
					+ File.separator + fileName;
			LogUtils.i("cc1", path);
			File file = new File(path);
			/**
			 * 判断文件是否存在，如果存在进行读写操作
			 */
			LogUtils.i("cc5", file.exists()+"");
			if(file.exists()){
				return 0;
			}
			else{
				return 1;
			}

		}
		else{
			return 3;
		}
		
	}

	/**
	 * 获得公共路径名
	 * 
	 * @param type
	 *            :公共文件夹的类型
	 * @return 有，返回，没有返回null
	 */
	public static String getSDCardPublicPath(String type) {
		if (isMounted()) {
			return Environment.getExternalStoragePublicDirectory(type)
					.getAbsolutePath();
		}
		return null;
	}

	/**
	 * 保存公共路径下
	 * 
	 * @param data
	 *            :保存的数据
	 * @param type
	 *            :公共文件夹的类型
	 * @param fileName
	 *            :文件名
	 * @return 保存成功返回true，否则返回false
	 */
	public static boolean saveDataIntoSDCardPublic(byte[] data, String type,
			String fileName) {
		if (isMounted()) {
			File file = new File(getSDCardPublicPath(type));
			// 判断文件路径是否存在，如果没有，创建一个
			if (!file.exists()) {
				file.mkdirs();
			}
			BufferedOutputStream bos = null;
			try {
				// 创建输出流
				bos = new BufferedOutputStream(new FileOutputStream(new File(
						file, fileName)));
				bos.write(data, 0, data.length);
				bos.flush();
				return true;
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				try {
					if (bos != null)
						bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return false;
	}

	/**
	 * 获得私有的路径名
	 * 
	 * @param type
	 *            :保存私有文件的类型
	 * @param context
	 *            :上下文
	 * @return 有，返回，没有返回null
	 */
	public static String getSDCardPrivatePath(String type, Context context) {
		if (isMounted()) {
			return context.getExternalFilesDir(type).getAbsolutePath();
		}
		return null;
	}

	/**
	 * 保存在sdcard的私有路径下
	 * 
	 * @param data
	 *            :保存的数据
	 * @param context
	 *            :上下文
	 * @param type
	 *            :保存私有文件的类型
	 * @param fileName
	 *            :文件名
	 * @return 保存成功返回true，失败返回false
	 */
	public static boolean saveDataIntoSDCardPrivate(byte[] data,
                                                    Context context, String type, String fileName) {
		File file = new File(getSDCardPrivatePath(type, context));
		// 判断文件夹是否存在，没有则创建
		if (!file.exists()) {
			file.mkdirs();
		}
		BufferedOutputStream bos = null;
		try {
			bos = new BufferedOutputStream(new FileOutputStream(new File(file,
					fileName)));
			bos.write(data, 0, data.length);
			bos.flush();
			return true;
		} catch (Exception e) {
		
			e.printStackTrace();
		} finally {
			try {
				if (bos != null) {

				}
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return false;
	}
}
